home *** CD-ROM | disk | FTP | other *** search
/ The Arsenal Files 4 / The Arsenal Files 4 (Arsenal Computer).ISO / ham / sattrk31.tgz / sattrack-3.1.tar / SatTrack / src / sattrack / satdisp.c < prev    next >
C/C++ Source or Header  |  1995-03-16  |  49KB  |  1,816 lines
  1. /******************************************************************************/
  2. /*                                                                            */
  3. /*  Title       : satdisp.c                                                   */
  4. /*  Author      : Manfred Bester                                              */
  5. /*  Date        : 24Feb92                                                     */
  6. /*  Last change : 15Mar95                                                     */
  7. /*                                                                            */
  8. /*  Synopsis    : This function block performs the live display part of the   */
  9. /*                satellite tracking program SatTrack.                        */
  10. /*                                                                            */
  11. /*                                                                            */
  12. /*  SatTrack is Copyright (c) 1992, 1993, 1994, 1995 by Manfred Bester.       */
  13. /*  All Rights Reserved.                                                      */
  14. /*                                                                            */
  15. /*  Permission to use, copy, and distribute SatTrack and its documentation    */
  16. /*  in its entirety for educational, research and non-profit purposes,        */
  17. /*  without fee, and without a written agreement is hereby granted, provided  */
  18. /*  that the above copyright notice and the following three paragraphs appear */
  19. /*  in all copies. SatTrack may be modified for personal purposes, but        */
  20. /*  modified versions may NOT be distributed without prior consent of the     */
  21. /*  author.                                                                   */
  22. /*                                                                            */
  23. /*  Permission to incorporate this software into commercial products may be   */
  24. /*  obtained from the author, Dr. Manfred Bester, 1636 M. L. King Jr. Way,    */
  25. /*  Berkeley, CA 94709, USA. Note that distributing SatTrack 'bundled' in     */
  26. /*  with ANY product is considered to be a 'commercial purpose'.              */
  27. /*                                                                            */
  28. /*  IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, */
  29. /*  SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OF   */
  30. /*  THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE AUTHOR HAS BEEN ADVISED  */
  31. /*  OF THE POSSIBILITY OF SUCH DAMAGE.                                        */
  32. /*                                                                            */
  33. /*  THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT      */
  34. /*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A   */
  35. /*  PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS"      */
  36. /*  BASIS, AND THE AUTHOR HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, */
  37. /*  UPDATES, ENHANCEMENTS, OR MODIFICATIONS.                                  */
  38. /*                                                                            */
  39. /******************************************************************************/
  40.  
  41. #include <stdio.h>
  42. #include <math.h>
  43. #include <string.h>
  44.  
  45. #ifndef STDLIB
  46. #include <stdlib.h>
  47. #endif
  48.  
  49. #include "satglobalsx.h"          /* external global variables                */
  50. #include "sattrack.h"             /* definition of various constants          */
  51.  
  52. #ifdef HPTERM
  53. #include "hpterm.h"               /* definitions of hpterm macros             */
  54. #else
  55. #include "vt100.h"                /* definitions of VT100 macros              */
  56. #endif
  57.  
  58. /******************************************************************************/
  59. /*                                                                            */
  60. /*  static variables                                                          */
  61. /*                                                                            */
  62. /******************************************************************************/
  63.  
  64. static int launchMsgA, launchMsgB, launchMsgC, launchMsgD;
  65. static int lastYearDay, reverseFlag;
  66. static int firstMultiSatDisp, poleFlag;
  67.  
  68. static char localDate[12], localTime[12];
  69.  
  70. /******************************************************************************/
  71. /*                                                                            */
  72. /* updateSingleSatLiveDisp: updates the tracking live display                 */
  73. /*                                                                            */
  74. /******************************************************************************/
  75.  
  76. void updateSingleSatLiveDisp(curTime,nextRiseTime,nextSetTime,
  77.             riseAzimuth,maxAzimuth,setAzimuth,maxElevation,maxRange)
  78.  
  79. double curTime, nextRiseTime, nextSetTime;
  80. double riseAzimuth, maxAzimuth, setAzimuth, maxElevation, maxRange;
  81.  
  82. {
  83.     double fabsMET, timeArg, cUnit;
  84.     double dispAzimuth   = ZERO;
  85.     double dispElevation = ZERO;
  86.     long   tDayNum;
  87.     int    tDay, tMonth, tYear, tYearDay, tHour, tMin, tSec;
  88.     int    i, lastHour, lastMin, lastSec;
  89.     char   str[80];
  90.  
  91.     if (preOrbitFlag)                       /* do not display negative orbits */
  92.     {
  93.         for (i = 0; i <= 2; i++)
  94.         {
  95.             satPosGl[i] = ZERO;
  96.             satVelGl[i] = ZERO;
  97.         }
  98.  
  99.         orbitNum      = FALSE;
  100.         orbitFract    = ZERO;
  101.         stsOrbitNum   = FALSE;
  102.         stsOrbitFract = ZERO;
  103.         downlinkDopp  = ZERO;
  104.         uplinkDopp    = ZERO;
  105.         downlinkLoss  = ZERO;
  106.         uplinkLoss    = ZERO;
  107.         squintAngle   = ZERO;
  108.         sunPhaseAngle = ZERO;
  109.         satPhase      = ZERO;
  110.         satAzimuth    = ZERO;
  111.         satElevation  = -ONEPPM / 2.0;
  112.         satRange      = ZERO;
  113.         rangeRate     = ZERO;
  114.         satVelocity   = ZERO;
  115.  
  116.         if (satTypeFlag == STS && preLaunchFlag)
  117.         {
  118.             satLat     = KSCLAT;
  119.             satLong    = KSCLONG;
  120.             satHeight  = KSCALT;
  121.             prevSatLat = KSCLAT - ONEPPM;
  122.         }
  123.  
  124.         else
  125.         {
  126.             satLat     = ZERO;
  127.             satLong    = ZERO;
  128.             satHeight  = ZERO;
  129.             prevSatLat = -ONEPPM;
  130.         }
  131.     }
  132.  
  133.     if (trackObject)
  134.     {
  135.         satRange      = ZERO;
  136.         rangeRate     = ZERO;
  137.     }
  138.  
  139.     cUnit = (satTypeFlag == STS) ? CKMNM : 1.0;
  140.  
  141.     if (satElevation > ZERO && !elevationFlag)
  142.     {
  143.         gotoXY(nX+headerCol,nY+1);
  144.         doBeep();
  145.         reverse();
  146.         printf("%s",header);
  147.         normal();
  148.         elevationFlag = TRUE;
  149.     }
  150.  
  151.     if (satElevation <= ZERO && elevationFlag)
  152.     {
  153.         gotoXY(nX+headerCol,nY+1);
  154.         doBeep();
  155.         underline();
  156.         printf("%s",header);
  157.         normal();
  158.         elevationFlag = FALSE;
  159.     }
  160.  
  161.     timeArg = curTime + timeZone;
  162.     tDayNum = (long) timeArg;
  163.     convertTime(timeArg,&dummyi,&tHour,&tMin,&tSec);
  164.     getDate(tDayNum,&tYear,&tMonth,&tDay,&tYearDay);
  165.  
  166.     sprintf(localDate,"%02d%3s%02d",tDay,monthName(tMonth),tYear%100);
  167.     sprintf(localTime,"%02d:%02d:%02d",tHour,tMin,tSec);
  168.     sprintf(xTimeStr,"%7s  %8s %s",localDate,localTime,timeZoneStr);
  169.  
  170.     if (tYearDay != lastYearDay)
  171.     {
  172.         gotoXY(nX+38,nY+3);
  173.         printf("%3s  %7s",dayName(tDayNum%7),localDate);
  174.         gotoXY(nX+38,nY+4);
  175.         printf("%-3d %8s",tYearDay,localTime);
  176.         lastYearDay = tYearDay;
  177.     }
  178.  
  179.     else
  180.     {
  181.         gotoXY(nX+42,nY+4);
  182.         printf("%8s",localTime);
  183.     }
  184.  
  185.     if (debugFlag)
  186.     {
  187.         gotoXY(nX+42,nY+5);
  188.         printf("%8ld",curYearSec);
  189.  
  190.         gotoXY(nX+42,nY+6);
  191.         convertTime(lasTime*CRREV,&dummyi,&lastHour,&lastMin,&lastSec);
  192.         printf("%02d:%02d:%02d",lastHour,lastMin,lastSec);
  193.     }
  194.  
  195.     if (trackDispFlag)
  196.     {
  197.         gotoXY(nX+46,nY+8);
  198.  
  199.         if (trackingFlag)
  200.         {
  201.             reverse();
  202.  
  203.             if (trackingFlag == ON)
  204.                 printf("  ON");
  205.  
  206.             if (trackingFlag == AUTOTRK)
  207.                 printf("AUTO");
  208.  
  209.             if (trackingFlag == ERROR)
  210.                 printf(" ERR");
  211.  
  212.             normal();
  213.         }
  214.  
  215.         else
  216.         {
  217.             printf(" OFF");
  218.         }
  219.  
  220.         trackDispFlag = FALSE;
  221.     }
  222.  
  223.     gotoXY(nX+18,nY+5);
  224.     printf("%7.3f",curInclination*CRD);
  225.  
  226.     if (satTypeFlag == STS)
  227.     {
  228.         gotoXY(nX+14,nY+6);
  229.         printf("%5ld",stsOrbitNum);
  230.         gotoXY(nX+20,nY+6);
  231.         printf("%5.1f",stsOrbitFract);
  232.     }
  233.  
  234.     else
  235.     {
  236.         gotoXY(nX+14,nY+6);
  237.         printf("%5ld",orbitNum);
  238.         gotoXY(nX+20,nY+6);
  239.         printf("%5.1f",orbitFract);
  240.     }
  241.  
  242.     gotoXY(nX+28,nY+6);
  243.  
  244.     if (orbitNum > 0 || stsOrbitNum > 0)
  245.     {
  246.         if (eclipseCode == VISIBLE) reverse();
  247.         printf("%s",visibCode[eclipseCode]);
  248.         if (eclipseCode == VISIBLE) normal();
  249.     }
  250.  
  251.     else
  252.         printf("%s",visibCode[BLANK]);
  253.  
  254.     if (newTrackObjectFlag)
  255.     {
  256.         gotoXY(nX+1,nY+7);
  257.         if (trackObject == SUN) reverse();
  258.         printf("Sun ");
  259.         if (trackObject == SUN) normal();
  260.     }
  261.  
  262.     gotoXY(nX+14,nY+7);
  263.     printf("%5.1f %5.1f",sunAzimuth*CRD,sunElevation*CRD);
  264.  
  265.     if (newTrackObjectFlag)
  266.     {
  267.         gotoXY(nX+1,nY+8);
  268.         if (trackObject == MOON) reverse();
  269.         printf("Moon");
  270.         if (trackObject == MOON) normal();
  271.     }
  272.  
  273.     gotoXY(nX+14,nY+8);
  274.     printf("%5.1f %5.1f",moonAzimuth*CRD,moonElevation*CRD);
  275.  
  276.     /* the next lines are useful for solar eclipses and testing purposes */
  277. /*
  278.     gotoXY(nX+13,nY+9);
  279.     printf("%6.1f %5.1f",sunLong*CRD,sunLat*CRD);
  280.  
  281.     gotoXY(nX+14,nY+9);
  282.     printf("%7.3f %7.3f",(sunAzimuth - moonAzimuth)*CRD,
  283.                          (sunElevation - moonElevation)*CRD);
  284. */
  285.  
  286.     /* the next lines are needed for checking the positions of Sun and Moon */
  287. /*
  288.     gotoXY(nX+0,nY+9);
  289.     printf("Sun   RA=%10.6f Dec=%10.6f R=%.3f",sunRA*CRH,sunDec*CRD,sunDist);
  290.     gotoXY(nX+0,nY+9);
  291.     printf("Moon  RA=%10.6f Dec=%10.6f R=%.3f",moonRA*CRH,moonDec*CRD,moonDist);
  292. */
  293.  
  294.     /* the next lines are needed for checking the orbit calculations */
  295. /*
  296.     gotoXY(nX+0,nY+9);
  297.     printf("Orbit: %.2f km x %.2f km",perigeeHeight,apogeeHeight);
  298. */
  299.  
  300.     /* the next lines are needed for checking the orbit number calculations */
  301. /*
  302.     if (debugFlag)
  303.     {
  304.         if(xTermFlag)
  305.         {
  306.             gotoXY(nX+0,nY+27);
  307.             printf("dH:%9.3f   MM0:%9.6f   MM:%9.6f",
  308.                 satRadius-perigeeHeight-EARTHRADIUS,
  309.                 epochMeanMotion,curMeanMotion);
  310.  
  311.             gotoXY(nX+0,nY+29);
  312.             printf("stsOrbit   :%9.3f",stsOrbit);
  313.             printf("  =  curOrbit:%9.3f  +  curArgPerigee:%9.3f",
  314.                     curOrbit,curArgPerigee*CRREV);
  315.  
  316.             gotoXY(nX+0,nY+30);
  317.             printf("curArgNodeX:%9.3f",curArgNodeX*CRREV);
  318.         }
  319.  
  320.         else
  321.         {
  322.             gotoXY(nX+0,nY+9);
  323.             printf("dH: %9.3f  ",satRadius-perigeeHeight-EARTHRADIUS);
  324.             printf("stsOrbit :%9.3f = curOrbit:%9.3f + curArgPerigee:%5.3f",
  325.                     curOrbit+curArgPerigee*CRREV,curOrbit,curArgPerigee*CRREV);
  326.         }
  327.     }
  328. */
  329.  
  330.     gotoXY(nX+61,nY+3);
  331.     printf("%-4s",downlinkMode);
  332.     gotoXY(nX+61,nY+4);
  333.     printf("%-4s",uplinkMode);
  334.  
  335.     if (satElevation > ZERO) reverse();
  336.     gotoXY(nX+67,nY+3);
  337.     printf("%10.4f",(downlinkFreq + freqOffset + downlinkDopp)*CHZMHZ);
  338.     gotoXY(nX+67,nY+4);
  339.     printf("%10.4f",(uplinkFreq + freqOffset*xponderSign + uplinkDopp)*CHZMHZ);
  340.  
  341.     gotoXY(nX+67,nY+5);
  342.     printf("%8.2f00",downlinkLoss);
  343.     gotoXY(nX+67,nY+6);
  344.     printf("%8.2f00",uplinkLoss);
  345.     gotoXY(nX+67,nY+7);
  346.  
  347.     if (attitudeFlag)
  348.         printf("%9.3f0",squintAngle*CRD);
  349.     else
  350.         printf("%9.3f0",sunPhaseAngle*CRD);
  351.  
  352.     gotoXY(nX+67,nY+8);
  353.     printf("%8.2f00",satPhase);
  354.  
  355.     if (!numModes && satElevation > ZERO) normal();
  356.     gotoXY(nX+78,nY+8);
  357.     printf("%-2s",modeString);
  358.     if (numModes && satElevation > ZERO) normal();
  359.  
  360.     if (trackObject == SAT)
  361.     {
  362.         dispAzimuth   = satAzimuth;
  363.         dispElevation = satElevation;
  364.     }
  365.  
  366.     if (trackObject == SUN)
  367.     {
  368.         dispAzimuth   = sunAzimuth;
  369.         dispElevation = sunElevation;
  370.     }
  371.  
  372.     if (trackObject == MOON)
  373.     {
  374.         dispAzimuth   = moonAzimuth;
  375.         dispElevation = moonElevation;
  376.     }
  377.  
  378.     gotoXY(nX+20,nY+10);
  379.     if (dispElevation > ZERO) reverse();
  380.     printf("%10.3f",dispAzimuth*CRD);
  381.     gotoXY(nX+20,nY+11);
  382.     printf("%10.3f",dispElevation*CRD);
  383.     gotoXY(nX+35,nY+11);
  384.  
  385.     if (newTrackObjectFlag)
  386.     {
  387.         printf("_");
  388.     }
  389.  
  390.     else
  391.     {
  392.         if (fabs(dispElevation) < ONEPPM && fabs(dispAzimuth) < ONEPPM)
  393.             printf("/");
  394.  
  395.         else
  396.         {
  397.             if (prevDispEle > -PI - ONEPPM)
  398.             {
  399.                 (dispElevation > prevDispEle) ? printf("/") : printf("\\");
  400.             }
  401.         }
  402.     }
  403.  
  404.     prevDispEle = dispElevation;
  405.  
  406.     if (dispElevation > ZERO && trackObject) normal();
  407.     gotoXY(nX+20,nY+12);
  408.     printf("%10.3f",satRange*cUnit);
  409.     gotoXY(nX+20,nY+13);
  410.     printf("%10.3f",rangeRate*cUnit);
  411.     if (dispElevation > ZERO && !trackObject) normal();
  412.  
  413.     newTrackObjectFlag = FALSE;
  414.  
  415.     gotoXY(nX+65,nY+10);
  416.     printf("%6.3f",fabs(satLat*CRD));
  417.     gotoXY(nX+76,nY+10);
  418.  
  419.     (satLat > ZERO) ? printf("N") : printf("S");
  420.     
  421.     if (prevSatLat > -PI - ONEPPM)
  422.     {
  423.         (satLat > prevSatLat) ? printf(" /") : printf(" \\");
  424.     }
  425.  
  426.     prevSatLat = satLat;
  427.     gotoXY(nX+64,nY+11);
  428.     printf("%7.3f",fabs(satLong*CRD));
  429.     gotoXY(nX+75,nY+11);
  430.  
  431.     (satLong > ZERO) ? printf(" W") : printf(" E");
  432.     
  433.     gotoXY(nX+61,nY+12);
  434.     if (satHeight < ZERO) reverseBlink();
  435.     printf("%10.3f",satHeight*cUnit);
  436.     if (satHeight < ZERO) normal();
  437.     gotoXY(nX+62,nY+13);
  438.     printf("%9.3f",satVelocity*cUnit);
  439.  
  440. /*
  441.     gotoXY(nX+18,nY+14);
  442.     printf("%+10.3f",sitePosGl[0]*cUnit);
  443.     gotoXY(nX+42,nY+14);
  444.     printf("%+10.3f",sitePosGl[1]*cUnit);
  445.     gotoXY(nX+66,nY+14);
  446.     printf("%+10.3f",sitePosGl[2]*cUnit);
  447. */
  448.  
  449.     gotoXY(nX+18,nY+15);
  450.     printf("%+10.3f",satPosGl[0]*cUnit);
  451.     gotoXY(nX+42,nY+15);
  452.     printf("%+10.3f",satPosGl[1]*cUnit);
  453.     gotoXY(nX+66,nY+15);
  454.     printf("%+10.3f",satPosGl[2]*cUnit);
  455.  
  456. /*
  457.     gotoXY(nX+18,nY+16);
  458.     printf("%+10.3f",satPosS[0]*cUnit);
  459.     gotoXY(nX+42,nY+16);
  460.     printf("%+10.3f",satPosS[1]*cUnit);
  461.     gotoXY(nX+66,nY+16);
  462.     printf("%+10.3f",satPosS[2]*cUnit);
  463. */
  464.  
  465.     gotoXY(nX+18,nY+16);
  466.     printf("%+10.3f",satVelGl[0]*cUnit);
  467.     gotoXY(nX+42,nY+16);
  468.     printf("%+10.3f",satVelGl[1]*cUnit);
  469.     gotoXY(nX+66,nY+16);
  470.     printf("%+10.3f",satVelGl[2]*cUnit);
  471.  
  472. /*
  473.     gotoXY(nX+18,nY+16);
  474.     printf("%+10.3f",satVelS[0]*cUnit);
  475.     gotoXY(nX+42,nY+16);
  476.     printf("%+10.3f",satVelS[1]*cUnit);
  477.     gotoXY(nX+66,nY+16);
  478.     printf("%+10.3f",satVelS[2]*cUnit);
  479. */
  480.  
  481. /*
  482.     gotoXY(nX+6,nY+27);
  483.     printf("Satellite:");
  484.     gotoXY(nX+18,nY+27);
  485.     printf("%+12.9f",localVecSatGl[0]);
  486.     gotoXY(nX+33,nY+27);
  487.     printf("%+12.9f",localVecSatGl[1]);
  488.     gotoXY(nX+48,nY+27);
  489.     printf("%+12.9f",localVecSatGl[2]);
  490.  
  491.     gotoXY(nX+6,nY+28);
  492.     printf("Sun:");
  493.     gotoXY(nX+18,nY+28);
  494.     printf("%+12.9f",localVecSunGl[0]);
  495.     gotoXY(nX+33,nY+28);
  496.     printf("%+12.9f",localVecSunGl[1]);
  497.     gotoXY(nX+48,nY+28);
  498.     printf("%+12.9f",localVecSunGl[2]);
  499.  
  500.     gotoXY(nX+6,nY+29);
  501.     printf("Moon:");
  502.     gotoXY(nX+18,nY+29);
  503.     printf("%+12.9f",localVecMoonGl[0]);
  504.     gotoXY(nX+33,nY+29);
  505.     printf("%+12.9f",localVecMoonGl[1]);
  506.     gotoXY(nX+48,nY+29);
  507.     printf("%+12.9f",localVecMoonGl[2]);
  508. */
  509.  
  510.     if (geoSyncFlag != GEOSTAT)
  511.     {
  512.         if (newRiseFlag)
  513.         {
  514.             gotoXY(nX+6,nY+18);
  515.  
  516.             if (satElevation <= ZERO)
  517.             {
  518.                 reverse();
  519.                 printf("Next AOS  :");
  520.                 normal();
  521.             }
  522.  
  523.             else
  524.                 printf("Last AOS  :");
  525.  
  526.             timeArg = nextRiseTime + timeZone;
  527.             tDayNum = (long) timeArg;
  528.             convertTime(timeArg,&dummyi,&tHour,&tMin,&tSec);
  529.             getDate(tDayNum,&dummyi,&dummyi,&dummyi,&tYearDay);
  530.             gotoXY(nX+18,nY+18);
  531.             printf("%3d/%02d:%02d:%02d",tYearDay,tHour,tMin,tSec);
  532.         }
  533.  
  534.         convertTime(ZERO,&tYearDay,&tHour,&tMin,&tSec);
  535.  
  536.         if (satElevation <= ZERO && nextRiseTime - curTime >= ZERO)
  537.             convertTime(nextRiseTime-curTime,&tYearDay,&tHour,&tMin,&tSec);
  538.  
  539.         if (satElevation > ZERO && nextSetTime - curTime >= ZERO)
  540.             convertTime(nextSetTime-curTime,&tYearDay,&tHour,&tMin,&tSec);
  541.  
  542.         if (tYearDay == 0 && tHour == 0 && tMin < 1)
  543.         {
  544.             countdownFlag = TRUE;
  545.             doBeep();
  546.         }
  547.  
  548.         else
  549.             countdownFlag = FALSE;
  550.  
  551.         if (countdownFlag && checkCountdown)
  552.         {
  553.             gotoXY(nX+6,nY+21);
  554.             reverseBlink();
  555.             printf("Countdown :");
  556.             normal();
  557.             checkCountdown = FALSE;
  558.         }
  559.  
  560.         if (!countdownFlag && !checkCountdown)
  561.         {
  562.             gotoXY(nX+6,nY+21);
  563.             reverse();
  564.             printf("Countdown :");
  565.             normal();
  566.             checkCountdown = TRUE;
  567.         }
  568.  
  569.         gotoXY(nX+18,nY+21);
  570.         if (countdownFlag || satElevation > ZERO) reverse();
  571.         printf("%3d/%02d:%02d:%02d",tYearDay,tHour,tMin,tSec);
  572.         if (countdownFlag || satElevation > ZERO) normal();
  573.  
  574.         if (satElevation > ZERO && passDispFlag)
  575.         {
  576.             gotoXY(nX+6,nY+18);
  577.             printf("Last AOS  :");
  578.             gotoXY(nX+6,nY+20);
  579.             reverse();
  580.             printf("Next LOS  :");
  581.             normal();
  582.             passDispFlag = FALSE;
  583.         }
  584.  
  585.         if (newRiseFlag)
  586.         {
  587.             convertTime(nextSetTime-nextRiseTime,&tYearDay,&tHour,&tMin,&tSec);
  588.             gotoXY(nX+18,nY+19);
  589.             printf("%3d/%02d:%02d:%02d",tYearDay,tHour,tMin,tSec);
  590.  
  591.             if (satElevation <= ZERO)
  592.             {
  593.                 gotoXY(nX+6,nY+20);
  594.                 printf("Next LOS  :");
  595.             }
  596.  
  597.             timeArg = nextSetTime + timeZone;
  598.             tDayNum = (long) timeArg;
  599.             convertTime(timeArg,&dummyi,&tHour,&tMin,&tSec);
  600.             getDate(tDayNum,&dummyi,&dummyi,&dummyi,&tYearDay);
  601.             gotoXY(nX+18,nY+20);
  602.             printf("%3d/%02d:%02d:%02d",tYearDay,tHour,tMin,tSec);
  603.  
  604.             gotoXY(nX+64,nY+18);
  605.             printf("%5.1f00",riseAzimuth*CRD);
  606.             gotoXY(nX+77,nY+18);
  607.             printf("%s",visibCode[eclipseRise]);
  608.  
  609.             gotoXY(nX+64,nY+19);
  610.             printf("%5.1f00",maxAzimuth*CRD);
  611.             gotoXY(nX+77,nY+19);
  612.             printf("%s",visibCode[eclipseMax]);
  613.  
  614.             gotoXY(nX+64,nY+20);
  615.             printf("%5.1f00",setAzimuth*CRD);
  616.             gotoXY(nX+77,nY+20);
  617.             printf("%s",visibCode[eclipseSet]);
  618.  
  619.             gotoXY(nX+61,nY+21);
  620.             if (maxElevation > MAXELELIMIT) reverse();
  621.             printf("%8.1f00",maxElevation*CRD);
  622.             gotoXY(nX+61,nY+22);
  623.             printf("%8.1f00",maxRange*cUnit);
  624.             if (maxElevation > MAXELELIMIT) normal();
  625.  
  626.             newRiseFlag  = FALSE;
  627.             passDispFlag = TRUE;
  628.         }
  629.     }
  630.  
  631.     if (launchFlag)
  632.     {
  633.         getMetStr(preLaunchFlag,curTime,launchEpoch,str);
  634.  
  635.         gotoXY(nX+17,nY+22);
  636.         printf("%s",str);
  637.         sprintf(xMetStr,"MET: %s",str);
  638.  
  639.         fabsMET = fabs(curTime - launchEpoch);
  640.  
  641.         if (fabsMET <= NINEMIN && fabsMET > ONEMIN && preLaunchFlag && 
  642.             !launchMsgA)
  643.         {
  644.             gotoXY(nX+6,nY+23);
  645.             doBeep();
  646.             reverse();
  647.             printf("Final Launch Countdown  ");
  648.             normal();
  649.             launchMsgA = TRUE;
  650.         }
  651.  
  652.         if (fabsMET <= ONEMIN && preLaunchFlag)
  653.         {
  654.             doBeep();
  655.  
  656.             if (!launchMsgB)
  657.             {
  658.                 gotoXY(nX+6,nY+23);
  659.                 reverseBlink();
  660.                 printf("Final Launch Countdown  ");
  661.                 normal();
  662.                 launchMsgB = TRUE;
  663.             }
  664.         }
  665.  
  666.         if (!preLaunchFlag && preOrbitFlag && !launchMsgC)
  667.         {
  668.             gotoXY(nX+6,nY+23);
  669.             doBeep();
  670.             reverse();
  671.             printf("Ascending to Orbit      ");
  672.             normal();
  673.             launchMsgC = TRUE;
  674.         }
  675.  
  676.         if (!preLaunchFlag && !preOrbitFlag && launchMsgC && !launchMsgD)
  677.         {
  678.             gotoXY(nX+1,nY+23);
  679.             doBeep();
  680.             clearCurs();
  681.             launchMsgD = TRUE;
  682.         }
  683.     }
  684.  
  685.     else
  686.         *xMetStr = '\0';
  687.  
  688.     getMaidenHead(satLat,satLong,maidenHead);
  689.  
  690.     getGroundTrack(satLat,satLong,
  691.                    &cityLat,&cityLong,&gndTrkDist,gndTrkDir,gndTrkCity);
  692.  
  693.     *xGndTrkStr = '\0';
  694.     poleFlag = FALSE;
  695.  
  696.     if (satTypeFlag == STS && launchFlag)
  697.     {
  698.         if (preLaunchFlag)
  699.         {
  700.             newCityNum =  -2;
  701.             gndTrkDist = 0.0;
  702.             sprintf(gndTrkDir,"N");
  703.             sprintf(gndTrkCity,"Launch Complex 39, KSC, FL, USA");
  704.         }
  705.  
  706.         if (!preLaunchFlag && preOrbitFlag)
  707.         {
  708.             newCityNum =  -3;
  709.             gndTrkDist = 0.0;
  710.             *maidenHead = '\0';
  711.             sprintf(gndTrkDir,"NE");
  712.             sprintf(gndTrkCity,"the Launch Pad --- Ascending to Orbit");
  713.         }
  714.     }
  715.  
  716.     if (satTypeFlag != STS && launchFlag && preOrbitFlag)
  717.     {
  718.         newCityNum =  -2;
  719.         gndTrkDist = 0.0;
  720.         *maidenHead = '\0';
  721.         sprintf(gndTrkDir,"N");
  722.         sprintf(gndTrkCity,"the Launch Pad");
  723.     }
  724.  
  725.     if (!launchFlag && preOrbitFlag)
  726.     {
  727.         clearLine(nX+15,nY+24);
  728.     }
  729.  
  730.     else
  731.     {
  732.         gotoXY(nX+15,nY+24);
  733.         printf("%6s",maidenHead);
  734.  
  735.         gotoXY(nX+24,nY+24);
  736.         printf("%7.1f ",gndTrkDist*cUnit);
  737.         printf("%2s %3s of ",(satTypeFlag == STS) ? "nm" : "km",gndTrkDir);
  738.  
  739.         poleFlag = (!strcmp(gndTrkCity,"North Pole") || 
  740.                     !strcmp(gndTrkCity,"South Pole")) ? TRUE : FALSE;
  741.  
  742.         if (oldCityNum != newCityNum)
  743.         {
  744.             if (poleFlag)                              /* North or South Pole */
  745.                 printf("the %-33s",gndTrkCity);
  746.             else
  747.                 printf("%-37s",gndTrkCity);
  748.         }
  749.     }
  750.  
  751.     sprintf(xGndTrkStr,"%6s    %6.1f %2s %3s of %s%s",maidenHead,
  752.             gndTrkDist*cUnit,(satTypeFlag == STS) ? "nm" : "km",
  753.             gndTrkDir,(poleFlag) ? "the " : "",gndTrkCity);
  754.  
  755.     oldCityNum = newCityNum;
  756.  
  757.     lastX = nX + 80;
  758.     lastY = nY + 24;
  759.  
  760.     gotoXY(lastX,lastY);
  761.     fflush(stdout);
  762.     return;
  763. }
  764.  
  765. /******************************************************************************/
  766. /*                                                                            */
  767. /* getMetStr: gets MET (mission elapsed time) character string                */
  768. /*                                                                            */
  769. /******************************************************************************/
  770.  
  771. void getMetStr(plFlag,cTime,lTime,mStr)
  772.  
  773. double cTime, lTime;
  774. int    plFlag;
  775. char   *mStr;
  776.  
  777. {
  778.     double MET;
  779.     int    METday, METhour, METmin, METsec;
  780.  
  781.     MET = cTime - lTime;
  782.  
  783.     if (plFlag)
  784.         MET *= -1.0;
  785.  
  786.     convertTime(MET,&METday,&METhour,&METmin,&METsec);
  787.  
  788.     if (plFlag)
  789.     {
  790.         if (METday)
  791.             sprintf(mStr,"%4d/%02d:%02d:%02d",
  792.                  -METday,METhour,METmin,METsec);
  793.         else
  794.             sprintf(mStr,"  -%d/%02d:%02d:%02d",
  795.                 -METday,METhour,METmin,METsec);
  796.     }
  797.  
  798.     else
  799.         sprintf(mStr,"%4d/%02d:%02d:%02d",METday,METhour,METmin,METsec);
  800.  
  801.     return;
  802. }
  803.  
  804. /******************************************************************************/
  805. /*                                                                            */
  806. /* updateMultiSatLiveDisp: updates the tracking live display for multiple     */
  807. /*                         satellites                                         */
  808. /*                                                                            */
  809. /******************************************************************************/
  810.  
  811. void updateMultiSatLiveDisp(curTime)
  812.  
  813. double curTime;
  814.  
  815. {
  816.     double timeArg, nxtRiseT, nxtSetT, elev, cUnit;
  817.     long   tDayNum;
  818.     int    i, j, k, n, slen, tYear, tMonth, tDay, tYearDay, tHour, tMin, tSec;
  819.     char   str[80];
  820.  
  821.     n = (gndTrkFlag) ? XDISPCOLUMNS - DISPCOLUMNS : 0;
  822.  
  823.     if (trackDispFlag)
  824.     {
  825.         if (xTermFlag)
  826.             gotoXY(69,3);
  827.         else
  828.             gotoXY(65,1);
  829.  
  830.         if (trackingFlag)
  831.         {
  832.             reverse();
  833.  
  834.             if (trackingFlag == ON)
  835.                 printf("  ON");
  836.  
  837.             if (trackingFlag == AUTOTRK)
  838.                 printf("AUTO");
  839.  
  840.             if (trackingFlag == ERROR)
  841.                 printf(" ERR");
  842.  
  843.             normal();
  844.         }
  845.  
  846.         else
  847.         {
  848.             if (!xTermFlag)
  849.             {
  850.                 underline();
  851.                 printf("    ");
  852.                 normal();
  853.             }
  854.  
  855.             else
  856.                 printf(" OFF");
  857.         }
  858.  
  859.         trackDispFlag = FALSE;
  860.     }
  861.  
  862.     timeArg = curTime + timeZone;
  863.     tDayNum = (long) timeArg;
  864.     convertTime(timeArg,&dummyi,&tHour,&tMin,&tSec);
  865.     getDate(tDayNum,&tYear,&tMonth,&tDay,&tYearDay);
  866.  
  867.     sprintf(localDate,"%02d%3s%02d",tDay,monthName(tMonth),tYear%100);
  868.     sprintf(localTime,"%02d:%02d:%02d",tHour,tMin,tSec);
  869.     sprintf(xTimeStr,"%7s  %8s %s",localDate,localTime,timeZoneStr);
  870.  
  871.     if (tYearDay != lastYearDay)
  872.     {
  873.         gotoXY(46+n,3);
  874.         printf("%3s  %7s",dayName(tDayNum%7),localDate);
  875.         gotoXY(67+n,3);
  876.         printf("%3d  %8s",tYearDay,localTime);
  877.         lastYearDay = tYearDay;
  878.     }
  879.  
  880.     else
  881.     {
  882.         gotoXY(72+n,3);
  883.         printf("%8s",localTime);
  884.     }
  885.  
  886.     if (numSats > numSatLines)
  887.     {
  888.         gotoXY(3,6);
  889.         printf("%3d-%3d (%3d)",satLinePtr+1,satLinePtr+numSatLines,numSats);
  890.     }
  891.  
  892.     sortSats();
  893.  
  894.     for (i = 0; i < numSatLines; i++)
  895.     {
  896.         j = satOrder[satLinePtr+i];
  897.  
  898.         elev     = sat[j].satEle;
  899.         nxtRiseT = sat[j].nextRiseT;
  900.         nxtSetT  = sat[j].nextSetT;
  901.  
  902.         gotoXY(1,i+7);
  903.  
  904.         if (sat[j].statusFl == SELECT)
  905.         {
  906.             reverse();
  907.             printf(">");
  908.             normal();
  909.             reverseFlag = FALSE;
  910.         }
  911.  
  912.         if (sat[j].statusFl == MARK)
  913.             printf("-");
  914.  
  915.         if (sat[j].statusFl == FALSE)
  916.             bl();
  917.  
  918.         if (sat[j].geosyncFl == GEOSTAT)
  919.         {
  920.             if (elev > ZERO)
  921.             {
  922.                 reverse();
  923.                 reverseFlag = TRUE;
  924.             }
  925.         }
  926.  
  927.         else
  928.         {
  929.             if (!sat[j].preorbitFl)
  930.             {
  931.                 if (elev <= ZERO && nxtRiseT-curTime < ONEMIN) 
  932.                 {
  933.                     if (sat[j].statusFl == SELECT)
  934.                         doBeep();
  935.  
  936.                     reverseBlink();
  937.                     reverseFlag  = TRUE;
  938.                     justAcquFlag = TRUE;
  939.                 }
  940.  
  941.                 if (elev > ZERO && fabs(nxtSetT-curTime) < ONEMIN) 
  942.                 {
  943.                     if (sat[j].statusFl == SELECT)
  944.                         doBeep();
  945.  
  946.                     reverseBlink();
  947.                     reverseFlag = TRUE;
  948.                 }
  949.  
  950.                 if (elev > ZERO && fabs(nxtSetT-curTime) >= ONEMIN) 
  951.                 {
  952.                     reverse();
  953.                     reverseFlag = TRUE;
  954.                 }
  955.  
  956.                 if (elev > TRACKLIMIT1 && nxtRiseT-curTime > TENMIN)
  957.                 {
  958.                     reverse();
  959.                     reverseFlag  = TRUE;
  960.                     justLostFlag = TRUE;
  961.                 }
  962.             }
  963.         }
  964.  
  965.         if (objectNumFlag)
  966.             sprintf(str,"%ld",sat[j].satIdNum);
  967.         else
  968.             sprintf(str,"%s",sat[j].satellite);
  969.  
  970.         printf("%-s",str);
  971.  
  972.         slen = strlen(str);
  973.  
  974.         if (slen < MAXSATNAMELEN)
  975.         {
  976.             bl();
  977.  
  978.             for (k = 0; k < MAXSATNAMELEN - slen - 1; k++)
  979.                 printf(".");
  980.         }
  981.  
  982.         if (debugFlag)
  983.         {
  984.             gotoXY(11,i+7);
  985.             if (sat[j].satTypeFl == STS)
  986.                 printf("%5.1f",sat[j].stsOrbFrac);
  987.             else
  988.                 printf("%5.1f",sat[j].satOrbFrac);
  989.         }
  990.  
  991.         if (justAcquFlag || justLostFlag)
  992.         {
  993.              normal();
  994.              reverseFlag  = FALSE;
  995.              justAcquFlag = FALSE;
  996.              justLostFlag = FALSE;
  997.         }
  998.  
  999.         if (sat[j].geosyncFl == GEOSTAT || sat[j].crashFl || sat[j].nopassFl)
  1000.         {
  1001.             if (sat[j].geosyncFl == GEOSTAT)
  1002.                 printf("  Geostationary satellite                     ");
  1003.  
  1004.             if (sat[j].crashFl)
  1005.             {
  1006.                 printf("  Satellite has crashed already");
  1007.                 clearCurs();
  1008.             }
  1009.  
  1010.             if (sat[j].geosyncFl != GEOSTAT && !sat[j].crashFl && 
  1011.                 sat[j].nopassFl)
  1012.             {
  1013.                 printf("  No pass for %6.3f days                     ",
  1014.                     nxtRiseT - curTime);
  1015.             }
  1016.         }
  1017.  
  1018.         else
  1019.         {
  1020.             convertTime(ZERO,&tYearDay,&tHour,&tMin,&tSec);
  1021.  
  1022.             if (elev <= ZERO && nxtRiseT-curTime >= ZERO)
  1023.                 convertTime(nxtRiseT-curTime,&tYearDay,&tHour,&tMin,&tSec);
  1024.  
  1025.             if (elev > ZERO && nxtSetT-curTime >= ZERO)
  1026.                 convertTime(nxtSetT-curTime,&tYearDay,&tHour,&tMin,&tSec);
  1027.  
  1028.             printf("%3d/%02d:%02d:%02d  ",tYearDay,tHour,tMin,tSec);
  1029.  
  1030.             if (elev <= ZERO)
  1031.             {
  1032.                 tDayNum = (long) (nxtRiseT + timeZone);
  1033.                 convertTime(nxtRiseT+timeZone,&dummyi,&tHour,&tMin,&tSec);
  1034.             }
  1035.  
  1036.             else
  1037.             {
  1038.                 tDayNum = (long) (nxtSetT + timeZone);
  1039.                 convertTime(nxtSetT+timeZone,&dummyi,&tHour,&tMin,&tSec);
  1040.             }
  1041.  
  1042.             getDate(tDayNum,&tYear,&tMonth,&tDay,&tYearDay);
  1043.             printf("%3d/%02d:%02d:%02d ",tYearDay,tHour,tMin,tSec);
  1044.  
  1045.             convertTime(nxtSetT-nxtRiseT,&tDay,&tHour,&tMin,&tSec);
  1046.             printf("%3d:%02d:%02d  ",tDay*24+tHour,tMin,tSec);
  1047.  
  1048.             printf("%2.0f",sat[j].maxEle*CRD);
  1049.  
  1050.             (sat[j].maxEle > MAXELELIMIT) ? printf("* ") : printf("  ");
  1051.  
  1052.             printf("%s%s%s ",visibCode[sat[j].eclRise],
  1053.                              visibCode[sat[j].eclMax],
  1054.                              visibCode[sat[j].eclSet]);
  1055.         }
  1056.  
  1057.         *xMetStr = '\0';
  1058.  
  1059.         if (sat[j].launchFl)
  1060.         {
  1061.             getMetStr(sat[j].prelaunchFl,curTime,sat[j].launchEp,str);
  1062.             sprintf(xMetStr,"MET: %s",str);
  1063.         }
  1064.  
  1065.         strcpy(sat[j].xMetStr,xMetStr);
  1066.  
  1067.         if (sat[j].launchFl && sat[j].preorbitFl)
  1068.         {
  1069.             reverse();
  1070.  
  1071.             if (sat[j].prelaunchFl)
  1072.                 printf("  not yet launched");
  1073.             else
  1074.                 printf("ascending to orbit");
  1075.  
  1076.             normal();
  1077.             reverseFlag = FALSE;
  1078.             clearCurs();
  1079.         }
  1080.  
  1081.         if (!sat[j].preorbitFl && !sat[j].crashFl)
  1082.         {
  1083.             printf("%s  ",visibCode[sat[j].eclCode]);
  1084.  
  1085.             printf("%3.0f %3.0f ",sat[j].satAzi*CRD,sat[j].satEle*CRD);
  1086.  
  1087.             if (firstMultiSatDisp)
  1088.                 printf("_");
  1089.  
  1090.             else
  1091.             {
  1092.                 if (sat[j].satLastEle < sat[j].satEle)
  1093.                     printf("/");
  1094.                 else
  1095.                     printf("\\");
  1096.             }
  1097.  
  1098.             printf("%6.0f",sat[j].satRng);
  1099.         }
  1100.  
  1101.         if (!sat[j].crashFl && gndTrkFlag)
  1102.         {
  1103.             if (!strncmp(sat[j].model,TLEMEANMODEL,4))
  1104.                 printf(" M ");
  1105.  
  1106.             if (!strncmp(sat[j].model,LOWEARTHMODEL,4))
  1107.                 printf(" G ");
  1108.  
  1109.             if (!strncmp(sat[j].model,DEEPSPACEMODEL,4))
  1110.                 printf(" D ");
  1111.         }
  1112.  
  1113.         if (!sat[j].preorbitFl && !sat[j].crashFl && gndTrkFlag)
  1114.         {
  1115.             printf("%4.0f km %3s %-37s",
  1116.                 sat[j].ctyDist,sat[j].ctyDir,sat[j].ctyStr);
  1117.         }
  1118.  
  1119.         if (reverseFlag)
  1120.         {
  1121.             normal();
  1122.             reverseFlag = FALSE;
  1123.         }
  1124.     }
  1125.  
  1126.     for (j = 0; j < numSats; j++)
  1127.     {
  1128.         if (sat[j].crashFl && sat[j].statusFl == SELECT)
  1129.             *xGndTrkStr = '\0';
  1130.  
  1131.         if (!sat[j].crashFl && sat[j].statusFl == SELECT)
  1132.         {
  1133.             poleFlag = (!strcmp(sat[j].ctyStr,"North Pole") || 
  1134.                         !strcmp(sat[j].ctyStr,"South Pole")) ? TRUE : FALSE;
  1135.  
  1136.             getMaidenHead(sat[j].satLtd,sat[j].satLng,maidenHead);
  1137.  
  1138.             cUnit = (sat[j].satTypeFl == STS) ? CKMNM : 1.0;
  1139.  
  1140.             sprintf(xGndTrkStr,"%6s    %6.1f %2s %3s of %s%s",maidenHead,
  1141.                 sat[j].ctyDist*cUnit,(sat[j].satTypeFl == STS) ? "nm" : "km",
  1142.                 sat[j].ctyDir,(poleFlag) ? "the " : "",sat[j].ctyStr);
  1143.         }
  1144.     }
  1145.  
  1146.     firstMultiSatDisp = FALSE;
  1147.  
  1148.     lastX = DISPCOLUMNS + n;
  1149.     lastY = numSatLines + 6;
  1150.  
  1151.     gotoXY(lastX,lastY);
  1152.     fflush(stdout);
  1153.     return;
  1154. }
  1155.  
  1156. /******************************************************************************/
  1157. /*                                                                            */
  1158. /* updateSatPointer: updates satellite pointer (cursor)                       */
  1159. /*                                                                            */
  1160. /******************************************************************************/
  1161.  
  1162. void updateSatPointer()
  1163.  
  1164. {
  1165.     int i, j, n;
  1166.  
  1167.     n = (gndTrkFlag) ? XDISPCOLUMNS - DISPCOLUMNS : 0;
  1168.  
  1169.     if (trackDispFlag)
  1170.     {
  1171.         if (xTermFlag)
  1172.             gotoXY(69,3);
  1173.         else
  1174.             gotoXY(65,1);
  1175.  
  1176.         if (trackingFlag)
  1177.         {
  1178.             reverse();
  1179.  
  1180.             if (trackingFlag == ON)
  1181.                 printf("  ON");
  1182.  
  1183.             if (trackingFlag == AUTOTRK)
  1184.                 printf("AUTO");
  1185.  
  1186.             if (trackingFlag == ERROR)
  1187.                 printf(" ERR");
  1188.  
  1189.             normal();
  1190.         }
  1191.  
  1192.         else
  1193.         {
  1194.             if (!xTermFlag)
  1195.             {
  1196.                 underline();
  1197.                 printf("    ");
  1198.                 normal();
  1199.             }
  1200.  
  1201.             else
  1202.                 printf(" OFF");
  1203.         }
  1204.  
  1205.         trackDispFlag = FALSE;
  1206.     }
  1207.  
  1208.     for (i = 0; i < numSatLines; i++)
  1209.     {
  1210.         j = satOrder[satLinePtr+i];
  1211.  
  1212.         gotoXY(1,i+7);
  1213.  
  1214.         if (sat[j].statusFl == SELECT)
  1215.         {
  1216.             reverse();
  1217.             printf(">");
  1218.             normal();
  1219.             reverseFlag = FALSE;
  1220.         }
  1221.  
  1222.         if (sat[j].statusFl == MARK)
  1223.             printf("-");
  1224.  
  1225.         if (sat[j].statusFl == FALSE)
  1226.             bl();
  1227.     }
  1228.  
  1229.     lastX = DISPCOLUMNS + n;
  1230.     lastY = numSatLines + 6;
  1231.  
  1232.     gotoXY(lastX,lastY);
  1233.     fflush(stdout);
  1234.     return;
  1235. }
  1236.  
  1237. /******************************************************************************/
  1238. /*                                                                            */
  1239. /* updateSatPage: updates satellite page in multisat display                  */
  1240. /*                                                                            */
  1241. /******************************************************************************/
  1242.  
  1243. void updateSatPage()
  1244.  
  1245. {
  1246.     int  i, j, n;
  1247.     char str[80];
  1248.  
  1249.     n = (gndTrkFlag) ? XDISPCOLUMNS - DISPCOLUMNS : 0;
  1250.  
  1251.     if (numSats > numSatLines)
  1252.     {
  1253.         gotoXY(3,6);
  1254.         printf("%3d-%3d (%3d)",satLinePtr+1,satLinePtr+numSatLines,numSats);
  1255.     }
  1256.  
  1257.     for (i = 0; i < numSatLines; i++)
  1258.     {
  1259.         clearLine(1,i+7);
  1260.         j = satOrder[satLinePtr+i];
  1261.  
  1262.         if (objectNumFlag)
  1263.             sprintf(str,"%ld",sat[j].satIdNum);
  1264.         else
  1265.             sprintf(str,"%s",sat[j].satellite);
  1266.  
  1267.         printf(" %-s",str);
  1268.     }
  1269.  
  1270.     updateSatPointer();
  1271.  
  1272.     lastX = DISPCOLUMNS + n;
  1273.     lastY = numSatLines + 6;
  1274.  
  1275.     gotoXY(lastX,lastY);
  1276.     fflush(stdout);
  1277.     return;
  1278. }
  1279.  
  1280. /******************************************************************************/
  1281. /*                                                                            */
  1282. /* initSingleSatLiveDisp: initializes live display (text strings)             */
  1283. /*                                                                            */
  1284. /******************************************************************************/
  1285.  
  1286. void initSingleSatLiveDisp()
  1287.  
  1288. {
  1289.     char stsUnit[6], str[80];
  1290.  
  1291.     launchMsgA         = FALSE;
  1292.     launchMsgB         = FALSE;
  1293.     launchMsgC         = FALSE;
  1294.     launchMsgD         = FALSE;
  1295.     trackDispFlag      = TRUE;
  1296.     elevationFlag      = FALSE;
  1297.     newTrackObjectFlag = TRUE;
  1298.     quickStartFlag     = FALSE;
  1299.     lastYearDay        = -1;
  1300.  
  1301.     gotoXY(1,1);
  1302.     clearScreen();
  1303.     dispTitle();
  1304.  
  1305.     gotoXY(nX+1,nY+3);
  1306.     printf("Ground Stn : %15s",siteName);
  1307.     advCurs(3);
  1308.     printf("Date: ___  _______");
  1309.     advCurs(3);
  1310.     printf("Downlnk ____: _____.____ MHz");
  1311.  
  1312.     gotoXY(nX+1,nY+4);
  1313.  
  1314.     if (strlen(satAlias))
  1315.     {
  1316.         if (satTypeFlag == STS)
  1317.             printf("Shuttle    : %15s",satAlias);
  1318.         else
  1319.             printf("Satellite  : %15s",satAlias);
  1320.     }
  1321.  
  1322.     else
  1323.         printf("Satellite  : %15s",satName);
  1324.  
  1325.     advCurs(3);
  1326.     printf("%-4s: ___ __:__:__",timeZoneStr);
  1327.     advCurs(3);
  1328.     printf("Uplink  ____: _____.____ MHz");
  1329.  
  1330.     gotoXY(nX+1,nY+5);
  1331.     printf("Inclination:     ___.___ deg");
  1332.  
  1333.     if (debugFlag)
  1334.     {
  1335.         advCurs(3);
  1336.         printf("UTC :     ________");
  1337.         advCurs(3);
  1338.     }
  1339.  
  1340.     else
  1341.         advCurs(24);
  1342.  
  1343.     printf("Downlnk Loss:  ____.____ dB");
  1344.  
  1345.     gotoXY(nX+1,nY+6);
  1346.     printf("Orbit      : _____ ___._ %% _");
  1347.  
  1348.     if (debugFlag)
  1349.     {
  1350.         advCurs(3);
  1351.         printf("LAST:     __:__:__");
  1352.         advCurs(3);
  1353.     }
  1354.  
  1355.     else
  1356.     {
  1357.         advCurs(3);
  1358.         printf("Object  :   %6ld",satNum);
  1359.         advCurs(3);
  1360.     }
  1361.  
  1362.     printf("Uplink  Loss:  ____.____ dB");
  1363.  
  1364.     gotoXY(nX+1,nY+7);
  1365.     printf("Sun   Az/El: ___._ -__._ deg");
  1366.     advCurs(3);
  1367.     printf("Model   :%9s",propModel);
  1368.     advCurs(3);
  1369.  
  1370.     if (attitudeFlag)
  1371.         printf("Squint Angle:  ____.____ deg");
  1372.     else
  1373.         printf("Sun Angle   :  ____.____ deg");
  1374.  
  1375.     gotoXY(nX+1,nY+8);
  1376.     printf("Moon  Az/El: ___._ -__._ deg");
  1377.     advCurs(3);
  1378.     printf("Tracking:     ____");
  1379.     advCurs(3);
  1380.     printf("Phase (%4.0f):  ____.____ __",maxPhase);
  1381.  
  1382.     gotoXY(nX+6,nY+10);
  1383.     printf("Azimuth   :      ___.___ deg");
  1384.     advCurs(12);
  1385.     printf("Latitude     :     __.___ deg _ _");
  1386.  
  1387.     gotoXY(nX+6,nY+11);
  1388.     printf("Elevation :      -__.___ deg _");
  1389.     advCurs(10);
  1390.     printf("Longitude    :    ___.___ deg _");
  1391.  
  1392.     sprintf(stsUnit,(satTypeFlag == STS) ? "nm" : "km");
  1393.  
  1394.     gotoXY(nX+6,nY+12);
  1395.     printf("Range     :   ______.___ %2s",stsUnit);
  1396.     advCurs(13);
  1397.     printf("Height       : ______.___ %2s",stsUnit);
  1398.  
  1399.     gotoXY(nX+6,nY+13);
  1400.     printf("Range Rate:    -____.___ %2s/s",stsUnit);
  1401.     advCurs(11);
  1402.     printf("Velocity     :  _____.___ %2s/s",stsUnit);
  1403.  
  1404. /*
  1405.     gotoXY(nX+1,nY+14);
  1406.     printf("Site  Vector  X: -_____.___ %2s",stsUnit);
  1407.     advCurs(8);
  1408.     printf("Y: -_____.___ %2s",stsUnit);
  1409.     advCurs(8);
  1410.     printf("Z: -_____.___ %2s",stsUnit);
  1411. */
  1412.  
  1413.     gotoXY(nX+1,nY+15);
  1414.     printf("State Vector  X: -_____.___ %2s",stsUnit);
  1415.     advCurs(8);
  1416.     printf("Y: -_____.___ %2s",stsUnit);
  1417.     advCurs(8);
  1418.     printf("Z: -_____.___ %2s",stsUnit);
  1419.  
  1420. /*
  1421.     gotoXY(nX+1,nY+16);
  1422.     printf("Norad Model   X: -_____.___ %2s",stsUnit);
  1423.     advCurs(8);
  1424.     printf("Y: -_____.___ %2s",stsUnit);
  1425.     advCurs(8);
  1426.     printf("Z: -_____.___ %2s",stsUnit);
  1427. */
  1428.  
  1429.     gotoXY(nX+1,nY+16);
  1430.     printf("             VX: -_____.___ %2s/s",stsUnit);
  1431.     advCurs(5);
  1432.     printf("VY: -_____.___ %2s/s",stsUnit);
  1433.     advCurs(5);
  1434.     printf("VZ: -_____.___ %2s/s",stsUnit);
  1435.  
  1436.     if (geoSyncFlag == GEOSTAT)
  1437.     {
  1438.         gotoXY(nX+12,nY+19);
  1439.         printf("Geostationary Satellite --- No Calculation of AOS and LOS");
  1440.     }
  1441.  
  1442.     else
  1443.     {
  1444.         gotoXY(nX+6,nY+18);
  1445.         printf("Next AOS  : ___/__:__:__ %-4s",timeZoneStr);
  1446.         advCurs(11);
  1447.         printf("AOS Azimuth  :    ___.___ deg  _");
  1448.  
  1449.         gotoXY(nX+6,nY+19);
  1450.         printf("Duration  : ___/__:__:__");
  1451.         advCurs(16);
  1452.         printf("MEL Azimuth  :    ___.___ deg  _");
  1453.  
  1454.         gotoXY(nX+6,nY+20);
  1455.         printf("Next LOS  : ___/__:__:__ %-4s",timeZoneStr);
  1456.         advCurs(11);
  1457.         printf("LOS Azimuth  :    ___.___ deg  _");
  1458.  
  1459.         gotoXY(nX+6,nY+21);
  1460.         reverse();
  1461.         printf("Countdown :");
  1462.         normal();
  1463.         printf(" ___/__:__:__");
  1464.         advCurs(16);
  1465.         printf("Max Elevation:     __.___ deg");
  1466.     }
  1467.  
  1468.     if (launchFlag)
  1469.     {
  1470.         gotoXY(nX+6,nY+22);
  1471.         printf("MET       : ___/__:__:__");
  1472.     }
  1473.  
  1474.     if (geoSyncFlag != GEOSTAT)
  1475.     {
  1476.         gotoXY(nX+46,nY+22);
  1477.         printf("MEL Range    : ______.___ %s",stsUnit);
  1478.     }
  1479.  
  1480.     gotoXY(nX+1,nY+24);
  1481.     sprintf(str,"_____________________________________");
  1482.     printf("Ground Track: ______   _____._ %2s ___ of %s",stsUnit,str);
  1483.  
  1484.     lastX = nX + 80;
  1485.     lastY = nY + 24;
  1486.  
  1487.     gotoXY(lastX,lastY);
  1488.     fflush(stdout);
  1489.     return;
  1490. }
  1491.  
  1492. /******************************************************************************/
  1493. /*                                                                            */
  1494. /* dispTitle: displays title for the single satellite live display            */
  1495. /*                                                                            */
  1496. /******************************************************************************/
  1497.  
  1498. void dispTitle()
  1499.  
  1500. {
  1501.     char satDispName[20], str[80], satStr[20];
  1502.  
  1503.     if (xTermFlag && didMultDispFlag)
  1504.     {
  1505.         nX = (numLinesX >= 30) ? 26 : 0;
  1506.         nY = (numLinesX >= 30) ?  2 : 0;
  1507.     }
  1508.  
  1509.     if (!xTermFlag || !didMultDispFlag)
  1510.     {
  1511.         nX = 0;
  1512.         nY = 0;
  1513.     }
  1514.  
  1515.     sprintf(satStr,"%s %s",sattrName,sattrVersion);
  1516.     sprintf(satDispName,"%s",satName);
  1517.     upperCase(satDispName);
  1518.     sprintf(header," %s %s ",satDispName,dispHeader);
  1519.     headerCol = 41 - (int) strlen(header) / 2;
  1520.  
  1521.     if (nX && nY)
  1522.     {
  1523.         gotoXY(nX,nY);
  1524.         underline();
  1525.         printf("%82c",' ');
  1526.  
  1527.         gotoXY(nX,nY+25);
  1528.         printf("%82c",' ');
  1529.         normal();
  1530.  
  1531.         sprintf(str,"%46s"," ");
  1532.         gotoXY(nX,nY+1);
  1533.     }
  1534.  
  1535.     else
  1536.     {
  1537.         sprintf(str,"%44s"," ");
  1538.         gotoXY(1,1);
  1539.     }
  1540.  
  1541.     underline();
  1542.     printf("%-14s %s %20s",satStr,str,callSign);
  1543.  
  1544.     gotoXY(nX+headerCol,nY+1);
  1545.     printf("%s",header);
  1546.     normal();
  1547.  
  1548.     return;
  1549. }
  1550.  
  1551. /******************************************************************************/
  1552. /*                                                                            */
  1553. /* initMultiSatLiveDisp: initializes multiple satellite live display          */
  1554. /*                                                                            */
  1555. /******************************************************************************/
  1556.  
  1557. void initMultiSatLiveDisp()
  1558.  
  1559. {
  1560.     int  i, j, n;
  1561.     char str[150], satStr[150];
  1562.  
  1563.     lastYearDay       = TRUE;
  1564.     trackDispFlag     = TRUE;
  1565.     reverseFlag       = FALSE;
  1566.     justLostFlag      = FALSE;
  1567.     didMultDispFlag   = TRUE;
  1568.     firstMultiSatDisp = TRUE;
  1569.     quickStartFlag    = FALSE;
  1570.  
  1571.     numSatLines = (xTermFlag) ? numLinesX - 6 : numLines - 6;
  1572.  
  1573.     if (numSats < numSatLines)
  1574.         numSatLines = numSats;
  1575.  
  1576.     n = (gndTrkFlag) ? XDISPCOLUMNS - DISPCOLUMNS : 0;
  1577.  
  1578.     gotoXY(1,1);
  1579.     clearScreen();
  1580.     underline();
  1581.     sprintf(satStr,"%8s %-6s",sattrName,sattrVersion);
  1582.  
  1583.     for (i = 0; i < 45 + n; i++)
  1584.         strcat(satStr," ");
  1585.  
  1586.     sprintf(satStr,"%s%20s",satStr,callSign);
  1587.     printf("%s",satStr);
  1588.  
  1589.     sprintf(header,"GROUP %s MULTISAT %s",satGroup,dispHeader);
  1590.     headerCol = (int) (DISPCOLUMNS + n + 1 - (int) strlen(header)) / 2;
  1591.     gotoXY(headerCol,1);
  1592.     printf("%s",header);
  1593.     normal();
  1594.  
  1595.     gotoXY(2,3);
  1596.  
  1597.     if (gndTrkFlag)
  1598.         printf("Ground Station: %-s",fullSiteName);
  1599.     else
  1600.         printf("Ground Station: %-s",siteName);
  1601.  
  1602.     if (xTermFlag)
  1603.     {
  1604.         gotoXY(59,3);
  1605.         printf("Tracking: ____");
  1606.     }
  1607.  
  1608.     gotoXY(40+n,3);
  1609.     printf("Date: ___  _______   %4s: ___  __:__:__",timeZoneStr);
  1610.  
  1611.     gotoXY(2,5);
  1612.     underline();
  1613.     printf("   Satellite  ");
  1614.     normal();
  1615.     bl();
  1616.     underline();
  1617.     printf(" Countdown ");
  1618.     normal();
  1619.     bl(); bl();
  1620.     underline();
  1621.     printf("Next AOS/LOS");
  1622.     normal();
  1623.     bl(); bl();
  1624.     underline();
  1625.     printf("Duration");
  1626.     normal();
  1627.     bl();
  1628.     underline();
  1629.     printf("MEL");
  1630.     normal();
  1631.     bl(); bl();
  1632.     underline();
  1633.     printf("Visib");
  1634.     normal();
  1635.     bl(); bl();
  1636.     underline();
  1637.     printf("Azi");
  1638.     normal();
  1639.     bl();
  1640.     underline();
  1641.     printf("Ele");
  1642.     normal();
  1643.     bl(); bl();
  1644.     underline();
  1645.     printf(" Range");
  1646.     normal();
  1647.  
  1648.     if (gndTrkFlag)
  1649.     {
  1650.         bl(); 
  1651.         underline();
  1652.         printf("M");
  1653.         normal();
  1654.         bl();
  1655.         underline();
  1656.         printf("              Ground Track Location              ");
  1657.         normal();
  1658.     }
  1659.  
  1660.     if (numSats > numSatLines)
  1661.     {
  1662.         gotoXY(3,6);
  1663.         printf("%3d-%3d (%3d)",satLinePtr+1,satLinePtr+numSatLines,numSats);
  1664.     }
  1665.  
  1666.     for (i = 0; i < numSatLines; i++)
  1667.     {
  1668.         gotoXY(2,i+7);
  1669.         j = satOrder[satLinePtr+i];
  1670.  
  1671.         if (objectNumFlag)
  1672.             sprintf(str,"%ld",sat[j].satIdNum);
  1673.         else
  1674.             sprintf(str,"%s",sat[j].satellite);
  1675.  
  1676.         printf("%-s",str);
  1677.     }
  1678.  
  1679.     updateSatPointer();
  1680.  
  1681.     lastX = DISPCOLUMNS + n;
  1682.     lastY = numSatLines + 6;
  1683.  
  1684.     gotoXY(lastX,lastY);
  1685.     fflush(stdout);
  1686.     return;
  1687. }
  1688.  
  1689. /******************************************************************************/
  1690. /*                                                                            */
  1691. /* initSortSats: initializes sortSats()                                       */
  1692. /*                                                                            */
  1693. /******************************************************************************/
  1694.  
  1695. void initSortSats()
  1696.  
  1697. {
  1698.     int i;
  1699.  
  1700.     for (i = 0; i < numSats; i++)
  1701.         satOrder[i] = i;
  1702.  
  1703.     return;
  1704. }
  1705.  
  1706. /******************************************************************************/
  1707. /*                                                                            */
  1708. /* sortSats: orders satellites that are below the horizon by rise time and    */
  1709. /*           those above the horizon by reverse set time                      */
  1710. /*                                                                            */
  1711. /******************************************************************************/
  1712.  
  1713. void sortSats()
  1714.  
  1715. {
  1716.     int i, j, tmpIndex;
  1717.  
  1718.     initSortSats();
  1719.  
  1720.     /* sort all satellites by rise time */
  1721.  
  1722.     for (i = 0; i < numSats; i++)
  1723.     {
  1724.         for (j = 0; j < numSats - 1; j++)
  1725.         {
  1726.             if (sat[satOrder[j]].nextRiseT >= sat[satOrder[j+1]].nextRiseT)
  1727.             {
  1728.                 tmpIndex      = satOrder[j];
  1729.                 satOrder[j]   = satOrder[j+1];
  1730.                 satOrder[j+1] = tmpIndex;
  1731.             } 
  1732.         }
  1733.     }
  1734.  
  1735.     /* resort all satellites that are above the horizon in reverse order */
  1736.  
  1737.     for (i = 0; i < numSats; i++)
  1738.     {
  1739.         for (j = 0; j < numSats - 1; j++)
  1740.         {
  1741.             if (sat[satOrder[j]].satEle   > ZERO && 
  1742.                 sat[satOrder[j+1]].satEle > ZERO && 
  1743.                 sat[satOrder[j]].nextSetT <= sat[satOrder[j+1]].nextSetT)
  1744.             {
  1745.                 tmpIndex      = satOrder[j];
  1746.                 satOrder[j]   = satOrder[j+1];
  1747.                 satOrder[j+1] = tmpIndex;
  1748.             }
  1749.         }
  1750.     }
  1751.  
  1752.     return;
  1753. }
  1754.  
  1755. /******************************************************************************/
  1756. /*                                                                            */
  1757. /* dispMessage: displays message string                                       */
  1758. /*                                                                            */
  1759. /******************************************************************************/
  1760.  
  1761. void dispMessage(msgStr)
  1762.  
  1763. char *msgStr;
  1764.  
  1765. {
  1766.     int  l, lCol, lRow;
  1767.     char dispStr[80];
  1768.  
  1769.     sprintf(dispStr,"%s ",msgStr);
  1770.  
  1771.     if (liveDispFlag == SINGLESAT)
  1772.     {
  1773.         if (xTermFlag && nX && nY)
  1774.         {
  1775.             if (numLinesX > 28)
  1776.                 lCol = (XDISPCOLUMNS - 80) / 2 + 1;
  1777.             else
  1778.                 lCol = (XDISPCOLUMNS - 80) / 2 - (int) strlen(dispStr);
  1779.  
  1780.             lRow = 29;
  1781.             clearLine(lCol,lRow);
  1782.             gotoXY(lCol,lRow);
  1783.         }
  1784.  
  1785.         else
  1786.         {
  1787.             oldCityNum = -1;
  1788.             clearLine(24,24);
  1789.             gotoXY(80 - (int) strlen(dispStr),24);
  1790.         }
  1791.  
  1792.         printf("%s",dispStr);
  1793.     }
  1794.  
  1795.     if (liveDispFlag == MULTISAT)
  1796.     {
  1797.         l = (xTermFlag) ? numLinesX : numLines;
  1798.         l = (xTermFlag && numSats < l - 9) ? numSats + 9 : l;
  1799.  
  1800.         clearLine(1,l);
  1801.         clearLine(1,l-1);
  1802.  
  1803.         printf(" %s",dispStr);
  1804.     }
  1805.  
  1806.     gotoXY(lastX,lastY);
  1807.     fflush(stdout);
  1808.     return;
  1809. }
  1810.  
  1811. /******************************************************************************/
  1812. /*                                                                            */
  1813. /* End of function satdisp.c                                                  */
  1814. /*                                                                            */
  1815. /******************************************************************************/
  1816.